返回首页

Java学习笔记——By Bug

前言

参考资料： 【Java入门基础视频教程，java零基础自学就选黑马程序员Java入门教程（含Java项目和Java真题）】 https://www.bilibili.com/video/BV1Cv411372m/?share_source=copy_web&vd_source=ea0cf64e8dac6f0193a7e28187a0fccb

Java下载：Java Downloads | Oracle

说明： 本笔记为本人学习过程中随手写的笔记，为复习使用，笔记中可能存在遗漏或错误，具体请以官方文档和权威书籍为准！谢谢！ 笔记中的一些图片等元素因路径配置问题，可能会发生丢失。 笔记中展示的构造器和方法等的知识点仅为部分内容，完整内容请查阅官方开发文档内容！

👇JavaSE👇

Java介绍

简介

什么是 Java 技术，为什么需要它？

Java 是 Sun Microsystems 于 1995 年首次发布的一种编程语言和计算平台。它已经从不起眼的开始发展到为当今数字世界的很大一部分提供动力，通过提供可靠的平台来构建许多服务和应用程序。为未来设计的创新产品和数字服务也继续依赖于 Java。

虽然大多数现代 Java 应用程序将 Java 运行时和应用程序结合在一起，但仍有许多应用程序甚至某些网站无法运行，除非您安装了桌面 Java。Java.com，这个网站，是为那些可能仍然需要 Java 的桌面应用程序（特别是面向 Java 8 的应用程序）的消费者准备的。

搭建开发环境

Java产品叫JDK（Java开发者工具包），必须安装JDK才能使用Java

1. 下载：Java Downloads | Oracle

2. 安装：运行安装包程序，安装软件 注意：安装目录尽量避免包含中文和空格 验证Java程序是否安装完成方法：

   xxxxxxxxxx
   #控制台命令
   java
   javac
   java -version
   javac -version
   

   

第一个Java程序

Java程序开发步骤：编写代码——编译代码——运行代码

1. 用记事本创建一个helloworld.java文件（文件名建议使用英文）

2. 编写java代码

   xxxxxxxxxx
   public class helloword{
        public static void main(String[] args){
           System.out.println("helloworld");
       }
   }
   

   文件名要于类名一致

3. 编译代码

   • 打开命令行窗口，运行javac helloworld.java

   • 会生成一个helloworld.class后缀的文件

4. 运行代码 命令行窗口运行：java helloworld

JDK组成和跨平台原理

JDK组成

• JVM（java virtual machine）：Java虚拟机，真正运行Java的地方

• 核心类库：Java写好的程序，程序员进行调用

• JRE：Java的运行环境

• 开发工具包：Java，Javac等...

跨平台原来

• 一次编译，处处可用

IntelliJ IDEA开发工具

概述 IntelliJ IDEA（简称 IDEA）是一款由 JetBrains 公司开发的强大且广受欢迎的集成开发环境（IDE），主要用于Java开发，但也支持其他编程语言和技术栈的开发。作为一款功能丰富、高效的IDE，IntelliJ IDEA 在软件开发领域中广泛用于开发各种类型的应用程序，从桌面应用到Web应用、移动应用、大数据和云计算应用等等。

1. 下载地址：Download IntelliJ IDEA – The Leading Java and Kotlin IDE (jetbrains.com) 下载社区版即可

2. 安装 运行idea安装程序

3. 汉化（非必须） 在插件中找到chinese汉化包，安装后冲的idea即可

新建项目

建议使用空项目

小技巧：快速创建main函数方法

1. 输入main，回车

2. 输入psvm，回车

示例代码

xxxxxxxxxx
package com.huang.hello;

public class sayhello {

    public static void main(String[] args) {
        System.out.println("hello world");
    }
    
}

IDEA配置

快捷键

入门内容

注释

xxxxxxxxxx
//单行注释,双斜杠
/*
多行注释
多行注释
多行注释
*/

/*
文档注释，可以提取到说明书中
**/

字面量

在Java中，字面量（literal）指人类可以阅读的固定值的表示。例如，数100是字面量。字面量也常常称为常量（constant）

Java的字面量可以是任意基本数据类型。每种字面量的表示取决于类型。如前所述，字符常量由单引号包括。例如，'a'和'%'都是字符常量。

变量

变量定义格式： 数据类型 变量名称=数据;

xxxxxxxxxx
//变量定义、使用及重新赋值 
public static void main(String[] args) {
        int a = 123;
        System.out.println(a);
        a+=2;
        System.out.println(a);
    }

注意：

1. 变量要先声明再使用

2. 变量是什么类型，对应的数据就要是什么类型，否则会报错

3. 定义多个变量，变量名不能相同

4. （局部）变量再当前作用域{}内有效，超出后无效

5. 变量在声明时可以不赋值，但在使用时必须要复制，否则将会报错

关键字与标识符

关键字 Java 中的关键字是指具有特定含义的单词或符号，这些关键字在 Java 编程中有着重要的作用。Java 关键字分为基本关键字、访问修饰符、类和接口关键字等。

标识符

Java 中的标识符是指用于命名变量、常量、方法、类、接口等的名称。Java 的标识符需要符合一定的规则，具体如下：

• 标识符可以包含字母、数字、下划线、美元符号等字符，但不能以数字开头，必能使用关键字；

• 标识符必须以字母、下划线或美元符号开头；

• 标识符不能使用 Java 中的关键字；

Java 中常用的标识符包括变量名、常量名、方法名、类名、接口名等。

===面向对象基础篇===

数据类型

基本数据类型

xxxxxxxxxx
 int a = 123456;
//数字类型默认为int，如果使用long类型，需要在最后加上L或l
long a2 = 1234567890098765;//报错
long a3 = 1234567890098765L;
//小数默认为double,使用float要在小数后面加F
float f=3.1415111F;
double d=3.1415111111111;

引用数据类型

String——字符串数据类型

数据类型转换

自动类型转换

• 类型范围小的变量可以直接赋值给范围大的变量

  xxxxxxxxxx
   byte a=1;
          System.out.println(getType(a));//byte
          int b = a;
          System.out.println(getType(b));//int
  

• 自动类型转换方向（从小到大） byte →short→int→long→float→double char→int

表达式的自动类型转换

xxxxxxxxxx
byte a=1;
short b =2;
int c = 3;
int d = a +b+c ;//结果为int

• 表达式的最终结果类型表达式中最高类型决定

• byte，short，char会转换成int类型参与运算

强制类型转换

大范围的变量赋值给小范围的时，需要强制类型转换

xxxxxxxxxx
//强制类型转换：数据类型 变量名 = (数据类型)数据
int a = 1;
//将a转换成byte类型
byte b = (byte)a;

注意：

• 强制类型转换可能会造成数据丢失

• 小数，浮点数转换成整数时，会舍弃小数部分，仅保留整数部分

运算符

算数运算符

可以使用 + 做连接符

自增自减运算符

赋值运算符

关系运算符

逻辑运算符

三元运算符

格式：表达式?值1:值2;

表达式为true时，返回值1，false时,返回值2

xxxxxxxxxx
int mat = 99;
String b = mat - 60 >= 60 ? "及格" : "不及格";
System.out.println(b);
String c = mat >= 60 ? "及格" : "不及格";
System.out.println(c);

运算符优先级

JavaAPI

API文档下载（以java21为例）：Java Development Kit 21 Documentation (oracle.com)

API使用：

1. 导入包

2. 使用包中的程序

例如使用scanner

xxxxxxxxxx
//导入包
import  java.util.Scanner;
public static void main(String[] args) {
//使用
        Scanner SC = new Scanner(System.in);
        int j = SC.nextInt();
        System.out.println(j);
}

流程控制

分支结构

if

if分支结构的三种形式

• 形式1

xxxxxxxxxx
if(表达式){
//code
}

• 形式2

xxxxxxxxxx
if(表达式){
//code
}
else{
//code
}

• 形式3

xxxxxxxxxx
if(表达式){
//code
}
else if(表达式){
//code
}
else{
//code
}

switch

语法：

xxxxxxxxxx
switch(表达式){
case 值1:
//code
break;
case 值2:
//code
break;
default:
//code
}

注意：

1. case的值只能是字面量，不能为变量，case的值不能重复

2. 语句结束后要使用break，否则会出现穿透现象

3. switch表达式类型只能是byte，short，int，char，enum，string不支持double,float,long

循环结构

for循环

xxxxxxxxxx
for (int i =0;i<5;i++){
    System.out.println(1);
}

案例

xxxxxxxxxx
//小鸡2元一只，公鸡3元一只，母鸡4元一只 用n元买每种鸡各多少只
        System.out.println("请输入金额");
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        for (int i = 0; i <= a / 4; i++) {
            for (int j = 0; j <= a / 3; j++) {
                for (int k = 0; k <= a / 2; k++) {
                    if(i*4+j*3+k*4==a){
                        System.out.println("小鸡：" + k + "只, 公鸡：" + j + "只, 母鸡：" + i + "只");
                    }
                }
            }
        }

while循环

xxxxxxxxxx
//while循环语法
while(条件){
    //code
}
//示例
int i =0;
while (i<5){
    System.out.println(i++);
}

do-while循环

xxxxxxxxxx
//do-while循环语法
do{
    //code
}while(条件);

//示例
int i =0;
do{
    System.out.println(i++);
}while (i<5);

//无论是否满足条件，都会打印一次
int i =0;
do{
    System.out.println(i++);
}while (i<0);//输出0

循环注意事项

while循环和do-while循环的区别：

• while循环是先判断条件是否成立，再执行程序语句

• do-while是先执行语句，再判断条件是否成立

死循环写法

xxxxxxxxxx
//写法1
for(;;){

}
//写法2
while(true){

}
//写法3
do{

}while(true);
//其他方法亦可

示例

xxxxxxxxxx
 //珠穆朗玛峰高度8848860mm，一张纸0.1mm求折叠多少次，能大于等于珠峰高度
double height = 8848860;
double paper = 0.1;
int i=0;
while (true){
    paper*=2;
    i++;
    if (paper>=height){
        System.out.println("当前高度:"+paper+"，条件满足"+"折叠了"+i+'次');
        break;
    }
}

跳转关键字

break---终止当前循环 只能用于所在循环，或结束所在switch分支的执行

continue---跳过本次循环 只能用于循环中

案例：生成随机数

xxxxxxxxxx
    //生成随机数，猜数字游戏
        Random r = new Random();
        int k = r.nextInt(10);
        int i;
        Scanner s = new Scanner(System.in);
        while (true) {
            System.out.println("请输入你猜的数字");
            i = s.nextInt();
            if (i == k) {
                System.out.println("对了");
                break;
            }
            else if(i > k) {
                System.out.println("大了，请重试");
            }
            else if(i < k) {
                System.out.println("小了，请重试");
            }
        }

数组

数组是一个容器，用来存储一批同类型的数据

静态数组初始化

初始化

xxxxxxxxxx
//完整格式
数据类型[] 数组名=new 数据类型[]{数值1，数值2，....}
int[] a=new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
//简化格式
数据类型[] 数组名={数值1，数值2，....}
int[] a= {1, 2, 3, 4, 5, 6, 7, 8, 9};

//注意事项
//数据类型[] 数组名 亦可写为数据类型 数组名[]
//存放的数据类型要和数据定义类型相同

静态数组访问

语法：数字名[索引号]

xxxxxxxxxx
int[] a= {22, 21, 33, 44, 55, 66, 77, 88, 99};
        System.out.println(a[0]);//22
        System.out.println(a[1]);//21
        System.out.println(a[2]);//33
        System.out.println(a[3]);//44
//修改数组数据
a[4]=100;

数组的最大索引长度：数组长度-1

数组遍历

xxxxxxxxxx
int[] a= {22, 21, 33, 44, 55, 66, 77, 88, 99};
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
//方法不唯一

动态初始化数组

数组的动态初始化——再定义数组时先不存入具体的元素值，只确定数组存储的数据类型和长度

动态初始化格式：

xxxxxxxxxx
//数据类型[] 数组名=new 数据类型[长度];
int[] a=new int[5];

案例：计算评分

xxxxxxxxxx
int[] fen = new int[5];
Scanner A = new Scanner(System.in);
for (int i = 0; i < fen.length; i++) {
    fen[i] = A.nextInt();
}
int sum = 0;
for (int i = 0; i < fen.length; i++) {
    sum += fen[i];
}
System.out.println(sum / fen.length);

案例：随机排名

xxxxxxxxxx
//有五个人，随机对五个人进行排序
int[] a = {1, 2, 3, 4, 5};
Random r = new Random();
int c= 0;
for (int i = 0; i < a.length; i++) {
    int b=r.nextInt(1,6);
    c =a[i];
    a[i]=a[b];
    a[b]=c;
}
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}

方法

方法是一种语法结构，它可以把一段代码封装成一个功能

方法定义

语法：

xxxxxxxxxx
修饰符 返回值类型 方法名(){
方法体代码
return 返回值;
}

方法定义时要注意： 1.方法是否需要接收处理数据 2.方法是否需要返回数据

xxxxxxxxxx
public static int sum(int a, int b) {
        return a + b;
    }

public static void main(String[] args) {
        System.out.println(sum(1, 2));//3
        System.out.println(sum(10, 20));//30
        
    }

注意事项

• 如果方法不需要返回数据，返回值类型必须申明成void（无返回值申明），此时方法内部不可以使用return返回数据。

• 方法如果不需要接收数据，则不需要定义形参，且调用方法时也不可以传数据给方法了。

• 没有参数，且没有返回值类型（void）申明的方法，称为无参数、无返回值的方法，依次类推。

方法使用的常见问题

• 方法在类中的位置前后无所谓，但一个方法不能定义在另一个方法里

• return语句以下不能编写语句，return以下的语句不会执行

• 方法不调用不会执行

• 返回值类型为void时，方法内不能使用return

• 调用无返回值的方法，只有一种方法：直接调用

• 调用有返回值的方法有三种：

  1. 可以定义变量接受结果

  2. 直接输出调用

  3. 直接调用

参数传递机制

java参数传递机制：值传递 指的是在传输实参给方法的形参时，传输的时实参变量中储存的值的副本

xxxxxxxxxx
    public static void change(int[] a){
        System.out.println("c1"+a[1]);
        a[1]=20;
        System.out.println("c2"+a[1]);
    }

    public static void main(String[] args) {
       int[] a=new  int[]{1,2,3,4};
       change(a);
        System.out.println("ma"+a[1]);

}

案例：打印int数组内容

xxxxxxxxxx
    public static void change(int[] a){
        System.out.print("[");
        for (int i = 0; i < a.length; i++) {
            if (i== a.length-1){
                System.out.print(a[i]);
            }
            else {
                System.out.print(a[i]+",");
            }
        }
        System.out.print("]");
    }

    public static void main(String[] args) {
       int[] a=new  int[]{1,2,3,4};
       change(a);
    }
       //输出：[1,2,3,4]

方法重载

在一个类中，出现多个重名方法，但是，它们的形参列表是不同的，那么这些方法就称为方法重载

xxxxxxxxxx
public static int sum(int[] a) {
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            sum += a[i];
        }
        return sum;
    }

    public static int sum(int a, int b) {
        return a + b;
    }
    public static int sum(int a){
        return a+6;
    }


    public static void main(String[] args) {
        int[] a = new int[]{1, 2, 3, 4};

        System.out.println(sum(a));
        System.out.println(sum(1, 2));
        System.out.println(sum(1));
        }

return关键字

return关键字可以用于无返回值的方法中 作用：立即跳出并结束当前方法

案例篇

买飞机票

需求 用户购买机票时，机票原价会按淡季，旺季，头等舱还是经济舱的情况进行相应的优惠方案，优惠方案如下：5-10月为旺季，头等舱9折，经济舱8.5折；11月-次年4月为淡季，头等舱7折，经济舱6.5折，请开发程序计算出用户当前机票的优惠价格

xxxxxxxxxx
public class buyplanepack {
    public static void main(String[] args) {
       int yuanjia;
        int month;
        String leave;
        Scanner a = new Scanner(System.in);
        System.out.println("请输入原价：");
        yuanjia = a.nextInt();
        System.out.println("请输入月份：");
        month = a.nextInt();
        System.out.println("请输入舱席：");
        leave = a.next();

        double last = airfare(yuanjia, month, leave);
        if (last>=0){
            System.out.println("优惠后机票价格：" + last + "元");
        } else if (last==-1) {
            System.out.println("你输入的月份不合法");

        }
        else if(last==-2){
            System.out.println("你输入的舱位不合法");
        }

       a.close();
    }

    public static  double airfare(int yuanjia, int month, String leave) {
        System.out.println();
        if (month >= 5 && month <= 10) {
            return switch (leave) {
                case "头等舱" -> yuanjia * 0.9;
                case "经济舱" -> yuanjia * 0.85;
                default -> -2;
            };

        }
        else if ((month >= 1 && month < 5) || (month > 10 && month <= 12)) {
            return switch (leave) {
                case "头等舱" -> yuanjia * 0.7;
                case "经济舱" -> yuanjia * 0.65;
                default -> -2;
            };

        }
        else {
            return -1;
        }

    }

}

验证码

需求 开发一个程序，可以生成指定位数的验证码，每位都可以输数字或大小写字母

xxxxxxxxxx
public class yanzhengma {
    public static void main(String[] args) {
        String A = yanzheng(7);//传入验证码的位数
        System.out.println(A);
    }

    public static String yanzheng(int a) {
        String b = "";
        Random c = new Random();
        int d;
        for (int i = 0; i < a; ) {
            d = c.nextInt(48,123);
            if ((d >= 48 && d <= 57) || (d >= 65 && d <= 90) || (d >= 97 && d <= 122)) {
                b += (char) d;
                i++;
            }
        }
        return b;
    }
}

评委打分

需求 在一个比赛中，有多名评委对选手进行打分，分数在0-100之间的整数，去掉打分中的最高分和最低分，对剩下的分数求平均，作为选手的最终得分

xxxxxxxxxx
package com.huang.anli;

import java.util.ArrayList;

import java.util.Scanner;

public class dafen {
    public static void main(String[] args) {
        ArrayList <Integer> a = new ArrayList<>();
        int in;
        System.out.println("请输入评委打分，输入-1结束");
        Scanner b = new Scanner(System.in);
        while (true) {
            in=b.nextInt();
            if (in!=-1){
                a.add(in);
            }
            else {
                break;
            }
        }
        double k = dafen(a);
        System.out.println(k);
    }
       
    public static double dafen(ArrayList<Integer> a) {
        int max=a.getFirst();
        int min=a.getFirst();
        for (int c :a){
            if(c>max){
                max=c;
            }
            if(c<min){
                min=c;
            }
        }
        a.remove(Integer.valueOf(max));
        a.remove(Integer.valueOf(min));
int sum=0;
for (int c :a){
    sum+=c;
}
    return (double) sum /a.size();

}}

数字加密

需求 某个系统的密码是一个四位数，如：1987，为了安全，需要对密码进行加密后在进行传输，加密规则：对密码中的每位数都加5，再对10求余数，得到一串加密后的新数

xxxxxxxxxx
public class jiami {
    //主函数
    public static void main(String[] args) {
        String e=jia(12345);
        System.out.println(e);
    }
    //加密方法
    public static String jia(int a) {
        //调用拆分方法
        int[] c =chai(a);
        //将拆分的数据进行加密
        for (int i = 0; i < c.length; i++) {
            c[i]=(c[i]+5)%10;
        }
        //将加密的数据反转后返回
        return zhuan(c);
    }
    //反转方法
    public static String zhuan(int[] c){
        int b =0;
        for (int i = 0; i < c.length/2; i++) {
            b=c[i];
            c[i]=c[c.length-i-1];
            c[c.length-i-1]=b;
        }
        StringBuilder j = new StringBuilder();
        for (int i = 0; i < c.length; i++) {
            j.append(c[i]);
        }
        return j.toString();
    }
    //拆分方法
    public static int[] chai(int a) {
        String s = Integer.toString(a);
        int[]b = new int[s.length()];

        for (int i = 0; i < s.length(); i++) {
            b[i] = Character.getNumericValue(s.charAt(i));
        }
        return b;
    }
}

数组拷贝

需求 现有一个数组a，拷贝一份一模一样的数组b

xxxxxxxxxx
public class copyint {
    public static void main(String[] args) {
        int[] a = {1, 4, 7, 9};
        int[] b = cp(a);
        int[] c=a;

        for (int i = 0; i < b.length; i++) {

            System.out.print(b[i]);
        }
        System.out.println();
        System.out.println(a);//a,b两个数组的内存地址不同
        System.out.println(b);
        System.out.println(c);//c和a的地址相同
    }

    private static int[] cp(int[] a) {
        int[] b = new int[a.length];
        for (int i = 0; i < a.length; i++) {
            b[i] = a[i];
        }
        return b;
    }

}

抢红包

需求 在一个活动中，有五个红包，金额为：9，199，520，666，999请模拟抽奖，每个红包只能抽一次，顺序随机

xxxxxxxxxx
import java.util.Random;

public class hongbao {
    public static void main(String[] args) {
        int[]bao ={9,199,520,666,999};
        chou(bao);

    }
    public static void chou(int[] a){
        Random R = new Random();


        for (int i = 0; ; ) {
            int c =R.nextInt(a.length);
            if (a[c]!=0){
            System.out.println("恭喜你，中奖了，金额："+a[c]);
            a[c]=0;
                i++;
            }
            if (i==5)break;
        }


    }
}

找素数

需求 输入开始和结束的两个数，判断之间有多少素数

xxxxxxxxxx
public class findsushu {
    public static void main(String[] args) {
        find(101, 200);
    }

    public static void find(int start, int end) {
        int ge = 0;

        for (int i = start; i <= end; i++) {
            boolean su = true;
            for (int j = 2; j < i / 2; j++) {
                if (i%j==0){
                    su=false;
                    break;
                }

            }
            if (su){
                System.out.println(i);
                ge++;

            }
        }
        System.out.println("素数个数" + ge);
    }
}

打印乘法表

需求 打印99乘法表

xxxxxxxxxx
public class chengfa99 {
    public static void main(String[] args) {
        for (int i = 1; i < 10; i++) {
            for (int j = 1; j <= i; j++) {

                System.out.print(j+"x"+i+"="+i*j+'\t');
            }
            System.out.println();
        }
    }
}

面向对象

入门示例

xxxxxxxxxx
//student类文件
package opp;

public class Student {
    String name;
    double chinese;
    double math;
    double english;
    public void sum(){
        System.out.println(name+"的总成绩："+(chinese+math+english));
    }
    public void avg(){
        System.out.println(name+"的平均成绩："+(chinese+math+english)/3.0);
    }
}

xxxxxxxxxx
//text类文件
package opp;

public class text {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.name="张三";
        s1.chinese=98;
        s1.math=88;
        s1.english=76;
        s1.sum();
        s1.avg();
    }
}

注意事项

1. 类名建议首字母大写，使用驼峰命名法。

2. 类中定义的变量也成为成员变量（对象的属性），类中定义的方法也成为成员方法（对象的行为）。

3. 成员对象本身存在默认值，在定义时一般情况下不对其进行赋值。

4. 一个代码文件中，可以有多个class，但只能有一个用public修饰，且public修饰的类名必须和文件名相同。

5. 对象和对象之间的数据不会相互影响，但多个变量指向同一个对象就会相互影响

6. 如果某个对象没有一个变量引用它，则该对象就无法被操作，该对象被称为垃圾对象

this关键字

this是什么？ this是一个变量，可以在方法中使用，来拿到当前对象

应用场景 this主要用来解决变量名称冲突问题

this可以获取当前对象的地址

xxxxxxxxxx
package opp;
//定义对象
public class trythis {
    //接收一个变量
    double sc;
    public void print(double sc){
        //在此两个sc，变量名冲突
        if (this.sc==sc){
            System.out.println("相等");
        }
        else {
            System.out.println("不相等");

        }
    }
}

//改进对象，避免变量名冲突问题
package opp;

public class trythis {
    //接收一个变量
    double sc;
    public void print(double sc){
        //在此两个sc，变量名冲突
        //this.sc代表trythis的sc,sc代表方法的形参，这样可以避免变量名冲突问题
        if (this.sc==sc){
            System.out.println("相等");
        }
        else {
            System.out.println("不相等");

        }
    }
}

package opp;

public class text {
    public static void main(String[] args) {
 //实例化对象
trythis a = new trythis();
a.sc=100;
a.print(100);

    }
}

构造器

构造器是一种特殊的方法，构造器名字要和class类的类名相同，且不能声明返回值类型

若不写构造器，Java会默认生成一个无参数构造器 一旦定义了有参构造器，Java就不会再默认提供无参数构造器

xxxxxxxxxx
//a1类文件
package com.learn.a1;

public class a1 {
    public a1(){
        System.out.println("触发了无参数构造器");
    }
    public a1(int a){
        System.out.println("触发了1个参数构造器");
    }
    public a1(int a,int b){
        System.out.println("触发了2个参数构造器");
    }
}


//a2类文件
package com.learn.a1;

public class a2 {
    public static void main(String[] args) {
        a1 s1 = new a1();
        a1 s2 = new a1(1);
        a1 s3 = new a1(1,2);
    }
}

//输出结果
/*
触发了无参数构造器
触发了1个参数构造器
触发了2个参数构造器
*/

封装

什么是封装？ 封装就是用类设计对象处理某一个事物的数据时，应该把要处理的数据以及处理的方法设计到一个对象中去

封装的设计规范 合理隐藏，合理暴露

控制对象的公开和隐藏

• 公开成员：使用public修饰

• 隐藏成员：使用private修饰

实体JavaBean

实体类：一种特殊形式的类

1. 这个类中的成员变量都要是私有的，并且要对外提供get，set方法

2. 这个类中必须有一个公共无参的构造器

xxxxxxxxxx
package com.learn.a1;

public class a1 {
    private string name;
    private int age;

    public string getName() {
        return name;
    }

    public void setName(string name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public a1(){
        System.out.println("触发了无参数构造器");
    }
}

应用场景

实体类只负责数据的存取，而对数据的处理由其他类来完成，实现数据和数据业务处理分离

xxxxxxxxxx
//数据存取类
package com.learn.a1;

public class a1 {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public a1(String a,int b){
        this.name=a;
        this.age=b;
    }
}

//数据操纵类
package com.learn.a1;

public class A1gop {
    private a1 data;
    public A1gop(){

    }
    public A1gop(a1 a){
        this.data=a;
    }
    public void yesno(){
        if(data.getAge()<18){
            System.out.println("未成年");
        }
        else if(data.getAge()>=18){
            System.out.println("成年");
        }
    }

}


//使用

package com.learn.a1;

public class a2 {
    public static void main(String[] args) {
        a1 s3 = new a1("张三",2);
        A1gop s = new A1gop(s3);
        s.yesno();
    }
}

综合案例——模仿电影信息系统

• 展示系统电影（电影名称，价格）

• 用户可以根据id查询详细信息

xxxxxxxxxx
//数据存取类
package com.learn.a1.move;

public class data {
   private int id;
   private String name;
   private String dates;
   private double srart;
   private String people;

    public data() {
    }

    public data(int id, String name, String dates, double srart, String people) {
        this.id = id;
        this.name = name;
        this.dates = dates;
        this.srart = srart;
        this.people = people;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDates() {
        return dates;
    }

    public void setDates(String dates) {
        this.dates = dates;
    }

    public double getSrart() {
        return srart;
    }

    public void setSrart(int srart) {
        this.srart = srart;
    }

    public String getPeople() {
        return people;
    }

    public void setPeople(String people) {
        this.people = people;
    }
}

xxxxxxxxxx
// 数据处理类
package com.learn.a1.move;

public class chulidata {
    private data[] data;

    public chulidata() {
    }

    public chulidata(com.learn.a1.move.data[] data) {
        this.data = data;
    }
    public void printmoves(){
        System.out.println("------系统全部电影------");
        for (int i = 0; i < data.length; i++) {
            System.out.println(String.format("ID：%d\t名称：%s\t上映时间：%s\t评分：%.2f\t作者：%s",
                    data[i].getId(),data[i].getName(),data[i].getDates(),data[i].getSrart(),data[i].getPeople()));
        }
    }
    public void findmv(int id){
        System.out.println("------你要查找的电影------");
        for (int i = 0; i < data.length; i++) {
            if (data[i].getId()==id){
                System.out.println(String.format("ID：%d\t名称：%s\t上映时间：%s\t评分：%.2f\t作者：%s",
                        data[i].getId(),data[i].getName(),data[i].getDates(),data[i].getSrart(),data[i].getPeople()));
            return;
            }

        }
        System.out.println("未查到相关电影");
    }
}

xxxxxxxxxx
//创建对象并使用
package com.learn.a1.move;

public class mainfun {
    public static void main(String[] args) {
        data d1 = new data(1,"猫和老鼠","2021-7-1",4.8,"张三");
        data d2 = new data(2,"西游记","2022-5-3",3.5,"里斯");
        data d3 = new data(3,"三国演义","2023-7-5",4.5,"赵六");
        data d4 = new data(4,"水浒传","2024-3-1",4.6,"王五");
        chulidata a = new chulidata(new data[]{d1, d2, d3, d4});
        a.printmoves();
        a.findmv(2);
        a.findmv(11);
    }
}
/*
------系统全部电影------
ID：1    名称：猫和老鼠 上映时间：2021-7-1   评分：4.80 作者：张三
ID：2    名称：西游记  上映时间：2022-5-3   评分：3.50 作者：里斯
ID：3    名称：三国演义 上映时间：2023-7-5   评分：4.50 作者：赵六
ID：4    名称：水浒传  上映时间：2024-3-1   评分：4.60 作者：王五
------你要查找的电影------
ID：2    名称：西游记  上映时间：2022-5-3   评分：3.50 作者：里斯
------你要查找的电影------
未查到相关电影
*/

成员变量和局部变量

两种变量的区别

总结

定义类的格式

xxxxxxxxxx
public class classname{
    //成员变量
    //成员方法
    //构造器
    //代码块
    //内部类
}

注意事项

1. 类名首字母大写，有意义，使用驼峰命名法，不能使用关键字，合法的标识符

2. 一个Java文件中可以定义多个类，但只能有一个是public修饰的，且public修饰的类必须和Java文件名相同

面向对象高级语法

JavaAPI

API：应用程序编程接口

JavaAPI文档：Java SE 文档 — API 和文档 | Oracle 中国

在自己程序中调用其他包的注意事项

• 在当前程序中，要调用自己包下的其他程序，可以直接调用（同一包下的类，可以相互调用）

• 在当前程序中，要调用其他包下的程序，必须在当前程序中导包，才可以访问。（导包：import 包名.类名）

• 在当前程序中，要调用Java提供的程序，也必须先导包，才可以使用。但Java.lang包下的程序是不需要导包的，可以直接使用

• 在当前程序中，要调用多个不同包下的程序，而这些程序名正好一样，默认只能导入一个程序，另一个程序必须带包名访问。

String

创建字符串的方式

1. Java程序中所有的字符串文字都是此类对象

   xxxxxxxxxx
   string name = "张三";
   string tex = "abcdefg";
   

2. 调用构造器初始化字符串对象 下面是常用的构造器

   构造器	说明
   public String()	创建一个空白的字符串对象，不含有任何内容
   public String(String tex)	根据传入的字符串，来创建字符串对象
   public String(char[] chars)	根据字符数组的内容，来创建字符串对象
   public String(byte[] bytes)	根据字节数组的内容，来创建字符串对象

   xxxxxxxxxx
   public class Main {
       public static void main(String[] args) {
           String a = "aaa";
           System.out.println(a);
   
           String b= new String();
           System.out.println(b);
   
           char[] c = {'你','h'};
           String d = new String(c);
           System.out.println(d);
   
           byte[] e = {98,99,100};
           String f = new String(e);
           System.out.println(f);
       }
   }
   /*
   输出
   aaa
   
   你h
   bcd
   */
   

    

String常用方法

xxxxxxxxxx
public class Main {
    public static void main(String[] args) {
        String a = "你好世界,hello";
        //获取字符串的长度
        System.out.println(a.length());//10

        //获取某个索引位置处的字符返回
        System.out.println("-----------");
        System.out.println(a.charAt(2));//世

        //将当前字符串转换成字符数组返回
        System.out.println("-----------");
        char[] b =a.toCharArray();
        for (int i = 0; i < b.length; i++) {
            System.out.println(b[i]);
        }/*
        你
        好
        世
        界
        ,
        h
        e
        l
        l
        o*/

        //判断当前字符串与另一个字符串内容是否一样
        System.out.println("-----------");
        String s1 = new String("世界");
        String s2 = new String("世界");
        System.out.println(s1 == s2);//false
        System.out.println(s1.equals(s2));//true

        //判断当前字符串与另一个字符串内容是否一样（忽略大小写）
        System.out.println("-----------");
        String pw1 ="a3AeEE";
        String pw2 ="A3aeee";
        System.out.println(pw1 == pw2);//false
        System.out.println(pw1.equalsIgnoreCase(pw2));//true

        //根据开始和结束索引进行截取字符串
        System.out.println("-----------");
        System.out.println(a.substring(1, 3));//好世

        //从开始索引进行截取字符串至结尾
        System.out.println("-----------");
        System.out.println(a.substring(1));//好世界,hello

        //使用新值替换字符串中的旧值
        System.out.println("-----------");
        String f =  a.replace("世界","world");//你好world,hello
        System.out.println(f);

        //判断字符串中是否包含某个字符
        System.out.println("-----------");
        System.out.println(a.contains("世界"));//true
        System.out.println(a.contains("hello1"));//false

        //判断字符串是否以某个字符串内容开头
        System.out.println("-----------");
        System.out.println(a.startsWith("你好"));//true
        System.out.println(a.startsWith("123"));//false

        //把字符串按照某个字样进行分割，并返回字符串数组
        System.out.println("-----------");
        String h = "张三，里斯，王五，赵六";
        String[] g = h.split("，");
        for (int i = 0; i < g.length; i++) {
            System.out.println(g[i]);
        }
        /*
            张三
            里斯
            王五
            赵六
        */

    }
}